<?php

class Usuario {
//<editor-fold defaultstate="collapsed" desc="Constantes">
  const NOMBRE_ENTIDAD = "Usuario";
  const SESION_MATRIZ_PERMISO = "UsuarioMatrizPermiso";
  const ARRAY_PERMISO_LISTADO_CATEGORIAS = 0;
  const ARRAY_PERMISO_LISTADO_PAGINAS = 1;
  const ARRAY_PERMISO_LISTADO_FUNCIONES = 2;
  const PERFIL_USUARIO = 1;
  const PERFIL_COMERCIAL = 2;
  const PERFIL_ADMINISTRADOR = 3;
  const PERFIL_WORKFLOW = 4;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Campos">
  private $_id;
  private $_username;
  private $_password;
  private $_nombre;
  private $_paterno;
  private $_materno;
  private $_email;
  private $_telefono;
  private $_fechaHoraUltimoAcceso;
  private $_ipUltimoAcceso;
  private $_fechaHoraCreacion;
  private $_fechaHoraModificacion;
  private $_esSuper;
  private $_rut;
  private $_dv;
  private $_direccion;
  private $_activo;
  private $_eliminado;
  private $_idPerfil;
  private $_perfilNombre;
  private $_perfilLlave;
  private $_existe;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Propiedades">
  public function getId() { return $this->_id; }
  public function setId($value) { $this->_id = $value; }

  public function getUsername() { return $this->_username; }
  public function setUsername($value) { $this->_username = $value; }

  public function getPassword() { return $this->_password; }
  public function setPassword($value) { $this->_password = $value; }

  public function getNombre() { return $this->_nombre; }
  public function setNombre($value) { $this->_nombre = $value; }

  public function getPaterno() { return $this->_paterno; }
  public function setPaterno($value) { $this->_paterno = $value; }

  public function getMaterno() { return $this->_materno; }
  public function setMaterno($value) { $this->_materno = $value; }

  public function getEmail() { return $this->_email; }
  public function setEmail($value) { $this->_email = $value; }

  public function getTelefono() { return $this->_telefono; }
  public function setTelefono($value) { $this->_telefono = $value; }

  public function getFechaHoraUltimoAcceso() { return $this->_fechaHoraUltimoAcceso; }
  public function setFechaHoraUltimoAcceso($value) { $this->_fechaHoraUltimoAcceso = $value; }

  public function getIpUltimoAcceso() { return $this->_ipUltimoAcceso; }
  public function setIpUltimoAcceso($value) { $this->_ipUltimoAcceso = $value; }

  public function getFechaHoraCreacion() { return $this->_fechaHoraCreacion; }
  public function setFechaHoraCreacion($value) { $this->_fechaHoraCreacion = $value; }

  public function getFechaHoraModificacion() { return $this->_fechaHoraModificacion; }
  public function setFechaHoraModificacion($value) { $this->_fechaHoraModificacion = $value; }

  public function getEsSuper() { return $this->_esSuper; }
  public function setEsSuper($value) { $this->_esSuper = $value; }

  public function getRut() { return $this->_rut; }
  public function setRut($value) { $this->_rut = $value; }

  public function getDv() { return $this->_dv; }
  public function setDv($value) { $this->_dv = $value; }

  public function getDireccion() { return $this->_direccion; }
  public function setDireccion($value) { $this->_direccion = $value; }

  public function getActivo() { return $this->_activo; }
  public function setActivo($value) { $this->_activo = $value; }

  public function getEliminado() { return $this->_eliminado; }
  public function setEliminado($value) { $this->_eliminado = $value; }

  public function getIdPerfil() { return $this->_idPerfil; }
  public function setIdPerfil($value) { $this->_idPerfil = $value; }

  public function getExiste() { return $this->_existe; }
  public function setExiste($value) { $this->_existe = $value; }

  public function getPerfilNombre() { return $this->_perfilNombre; }
  public function setPerfilNombre($value) { $this->_perfilNombre = $value; }

  public function getPerfilLlave() { return $this->_perfilLlave; }
  public function setPerfilLlave($value) { $this->_perfilLlave = $value; }

  public function getNombreCompleto() {
    $nombre = "";
    $nombre = (Utilidades::isNullOrEmpty($this->_nombre)) ? "" : $this->_nombre;
    $nombre = $nombre . ((Utilidades::isNullOrEmpty($this->_paterno)) ? "" : " " . $this->_paterno);
    $nombre = $nombre . ((Utilidades::isNullOrEmpty($this->_materno)) ? "" : " " . $this->_materno);
    return $nombre;
  }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Publicos">
  /**
   * constructor
   * @author VSR, 15/05/2012
   */
  public function __construct() {
    try {
      $this->_id = -1;
      $this->_username = "";
      $this->_password = "";
      $this->_nombre = "";
      $this->_paterno = "";
      $this->_materno = "";
      $this->_email = "";
      $this->_telefono = "";
      $this->_fechaHoraUltimoAcceso = "";
      $this->_ipUltimoAcceso = "";
      $this->_fechaHoraCreacion = "";
      $this->_fechaHoraModificacion = "";
      $this->_esSuper = 0;
      $this->_rut = "";
      $this->_dv = "";
      $this->_direccion = "";
      $this->_activo = 0;
      $this->_eliminado = 0;
      $this->_idPerfil = -1;
      $this->_perfilNombre = "";
      $this->_perfilLlave = "";
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * obtiene registro por su id
   * @author VSR, 15/05/2012
   */
  public function obtenerPorId($id = -1) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_ObtenerPorId({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = (is_null($row["Id"]) ) ? -1 : $row["Id"];
        $this->_username = ( is_null($row["Username"]) ) ? "" : $row["Username"];
        $this->_password = ( is_null($row["Password"]) ) ? "" : $row["Password"];
        $this->_nombre = ( is_null($row["Nombre"]) ) ? "" : $row["Nombre"];
        $this->_paterno = ( is_null($row["Paterno"]) ) ? "" : $row["Paterno"];
        $this->_materno = ( is_null($row["Materno"]) ) ? "" : $row["Materno"];
        $this->_email = ( is_null($row["Email"]) ) ? "" : $row["Email"];
        $this->_telefono = ( is_null($row["Telefono"]) ) ? "" : $row["Telefono"];
        $this->_fechaHoraUltimoAcceso = ( is_null($row["FechaHoraUltimoAcceso"]) ) ? "" : $row["FechaHoraUltimoAcceso"];
        $this->_ipUltimoAcceso = ( is_null($row["IpUltimoAcceso"]) ) ? "" : $row["IpUltimoAcceso"];
        $this->_fechaHoraCreacion = ( is_null($row["FechaHoraCreacion"]) ) ? "" : $row["FechaHoraCreacion"];
        $this->_fechaHoraModificacion = ( is_null($row["FechaHoraModificacion"]) ) ? "" : $row["FechaHoraModificacion"];
        $this->_esSuper = ( is_null($row["EsSuper"]) ) ? 0 : $row["EsSuper"];
        $this->_rut = ( is_null($row["Rut"]) ) ? "" : $row["Rut"];
        $this->_dv = ( is_null($row["Dv"]) ) ? "" : $row["Dv"];
        $this->_direccion = ( is_null($row["Direccion"]) ) ? "" : $row["Direccion"];
        $this->_activo = ( is_null($row["Activo"]) ) ? 0 : $row["Activo"];
        $this->_eliminado = ( is_null($row["Eliminado"]) ) ? 0 : $row["Eliminado"];
        $this->_idPerfil = ( is_null($row["IdPerfil"]) ) ? -1 : $row["IdPerfil"];
        $this->_perfilNombre = "";
        $this->_perfilLlave = "";
        $this->_existe = ($this->_id == -1) ? 0 : 1;
      } else {
        $this->_id = -1;
        $this->_username = "";
        $this->_password = "";
        $this->_nombre = "";
        $this->_paterno = "";
        $this->_materno = "";
        $this->_email = "";
        $this->_telefono = "";
        $this->_fechaHoraUltimoAcceso = "";
        $this->_ipUltimoAcceso = "";
        $this->_fechaHoraCreacion = "";
        $this->_fechaHoraModificacion = "";
        $this->_esSuper = 0;
        $this->_rut = "";
        $this->_dv = "";
        $this->_direccion = "";
        $this->_activo = 0;
        $this->_eliminado = 0;
        $this->_idPerfil = -1;
        $this->_perfilNombre = "";
        $this->_perfilLlave = "";
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * crea o actualiza un registro
   * @author VSR, 15/05/2012
   */
  public function grabar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_Grabar({id},'{username}','{password}','{nombre}','{paterno}','{materno}','{email}','{telefono}','{fechaHoraUltimoAcceso}','{ipUltimoAcceso}','{fechaHoraCreacion}','{fechaHoraModificacion}',{esSuper},'{rut}','{dv}','{direccion}',{activo},{eliminado},{idPerfil});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);
      $sp = str_replace("{username}", $this->_username, $sp);
      $sp = str_replace("{password}", $this->_password, $sp);
      $sp = str_replace("{nombre}", $this->_nombre, $sp);
      $sp = str_replace("{paterno}", $this->_paterno, $sp);
      $sp = str_replace("{materno}", $this->_materno, $sp);
      $sp = str_replace("{email}", $this->_email, $sp);
      $sp = str_replace("{telefono}", $this->_telefono, $sp);
      $sp = str_replace("{fechaHoraUltimoAcceso}", $this->_fechaHoraUltimoAcceso, $sp);
      $sp = str_replace("{ipUltimoAcceso}", $this->_ipUltimoAcceso, $sp);
      $sp = str_replace("{fechaHoraCreacion}", $this->_fechaHoraCreacion, $sp);
      $sp = str_replace("{fechaHoraModificacion}", $this->_fechaHoraModificacion, $sp);
      $sp = str_replace("{esSuper}", $this->_esSuper, $sp);
      $sp = str_replace("{rut}", $this->_rut, $sp);
      $sp = str_replace("{dv}", $this->_dv, $sp);
      $sp = str_replace("{direccion}", $this->_direccion, $sp);
      $sp = str_replace("{activo}", $this->_activo, $sp);
      $sp = str_replace("{eliminado}", $this->_eliminado, $sp);
      $sp = str_replace("{idPerfil}", $this->_idPerfil, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = $row["Id"];
        $this->_existe = 1;
      } else {
        $this->_id = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * elimina un registro
   * @author VSR, 15/05/2012
   */
  public function eliminar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_Eliminar({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      $this->_id = -1;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * destructor
   * @author VSR, 15/05/2012
   */
  public function __destruct() {
    // destruye el objeto
  }

  /**
   * verifica si el usuario se puede loguear
   * @author VSR, 01/01/2011
   */
  public function login() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_Login('{username}','{password}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{username}", $this->_username, $sp);
      $sp = str_replace("{password}", $this->_password, $sp);

      //ejecuta procedimiento
      $idUsuario = Bd::exec($sp, Bd::SCALAR);
      $idUsuario = (is_null($idUsuario)) ? -1 : $idUsuario;
      return $idUsuario;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * verifica si el usuario se puede loguear
   * @author JBC, 24/11/2011
   */
  public function loginWf() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_LoginWf('{username}','{password}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{username}", $this->_username, $sp);
      $sp = str_replace("{password}", $this->_password, $sp);

      //ejecuta procedimiento
      $oUsuario = Bd::exec($sp);

      $idUsuario = Bd::exec($sp, Bd::SCALAR);
      $idUsuario = (is_null($idUsuario)) ? -1 : $idUsuario;
      return $idUsuario;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Compartidos">
  /**
   * obtiene la matriz de permiso del usuario
   * @param <type> $idUsuario
   * @param <type> $esSuper
   * @return <type>
   * @author VSR, 01/01/2011
   */
  public static function obtenerMatrizPermisos($idUsuario, $esSuper) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_ObtenerMatrizPermisos({id},{esSuper});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $idUsuario, $sp);
      $sp = str_replace("{esSuper}", $esSuper, $sp);

      //ejecuta procedimiento
      $ds = Bd::exec($sp, Bd::MULTI_QUERY);
      return $ds;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * obtiene listado de usuarios
   * @param <type> $idUsuario
   * @param <type> $filtroNombre
   * @param <type> $filtroUsername
   * @param <type> $idPerfil
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function obtenerListadoConFiltro($idUsuario, $filtroNombre, $filtroUsername, $idPerfil) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_ObtenerListadoConFiltro({idUsuario},'{filtroNombre}','{filtroUsername}',{idPerfil});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{filtroNombre}", $filtroNombre, $sp);
      $sp = str_replace("{filtroUsername}", $filtroUsername, $sp);
      $sp = str_replace("{idPerfil}", $idPerfil, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene los datos personales de un usuario
   * @param <type> $idUsuario
   * @param <type> $entidadFirma
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function obtenerDatosPersonales($idUsuario, $entidadFirma) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_ObtenerDatosPersonales({idUsuario},'{entidadFirma}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{entidadFirma}", $entidadFirma, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba los datos de un usuario
   * @param <type> $idUsuario
   * @param <type> $nombre
   * @param <type> $paterno
   * @param <type> $materno
   * @param <type> $username
   * @param <type> $password
   * @param <type> $email
   * @param <type> $telefono
   * @param <type> $esSuper
   * @param <type> $activo
   * @param <type> $idPerfil
   * @param <type> $listadoPermisos
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function grabarDatos($idUsuario, $nombre, $paterno, $materno, $username, $password, $email, $telefono, $esSuper, $activo, $idPerfil, $listadoPermisos,
                                     $rut, $dv, $direccion, $listadoIdEmpresas, $idUsuarioConectado) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_GrabarDatos({idUsuario},'{nombre}', '{paterno}', '{materno}', '{username}', '{password}', '{email}', '{telefono}', {esSuper}, {activo}, {idPerfil}, '{listadoPermisos}','{rut}','{dv}','{direccion}','{listadoIdEmpresas}',{idUsuarioConectado});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{paterno}", $paterno, $sp);
      $sp = str_replace("{materno}", $materno, $sp);
      $sp = str_replace("{username}", $username, $sp);
      $sp = str_replace("{password}", $password, $sp);
      $sp = str_replace("{email}", $email, $sp);
      $sp = str_replace("{telefono}", $telefono, $sp);
      $sp = str_replace("{esSuper}", $esSuper, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{idPerfil}", $idPerfil, $sp);
      $sp = str_replace("{listadoPermisos}", $listadoPermisos, $sp);
      $sp = str_replace("{rut}", $rut, $sp);
      $sp = str_replace("{dv}", $dv, $sp);
      $sp = str_replace("{direccion}", $direccion, $sp);
      $sp = str_replace("{listadoIdEmpresas}", $listadoIdEmpresas, $sp);
      $sp = str_replace("{idUsuarioConectado}", $idUsuarioConectado, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * actualiza los datos del usuario
   * @param <type> $idUsuario
   * @param <type> $nombre
   * @param <type> $paterno
   * @param <type> $materno
   * @param <type> $username
   * @param <type> $password
   * @param <type> $email
   * @param <type> $telefono
   * @param <type> $esSuper
   * @param <type> $activo
   * @param <type> $idPerfil
   * @param <type> $listadoPermisos
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function modificarDatos($idUsuario, $nombre, $paterno, $materno, $username, $password, $email, $telefono, $esSuper, $activo, $idPerfil, $listadoPermisos,
                                        $rut, $dv, $direccion, $listadoIdEmpresas, $idUsuarioConectado) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_ModificarDatos({idUsuario},'{nombre}', '{paterno}', '{materno}', '{username}', '{password}', '{email}', '{telefono}', {esSuper}, {activo}, {idPerfil}, '{listadoPermisos}','{rut}','{dv}','{direccion}', '{listadoIdEmpresas}',{idUsuarioConectado});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{paterno}", $paterno, $sp);
      $sp = str_replace("{materno}", $materno, $sp);
      $sp = str_replace("{username}", $username, $sp);
      $sp = str_replace("{password}", $password, $sp);
      $sp = str_replace("{email}", $email, $sp);
      $sp = str_replace("{telefono}", $telefono, $sp);
      $sp = str_replace("{esSuper}", $esSuper, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{idPerfil}", $idPerfil, $sp);
      $sp = str_replace("{listadoPermisos}", $listadoPermisos, $sp);
      $sp = str_replace("{rut}", $rut, $sp);
      $sp = str_replace("{dv}", $dv, $sp);
      $sp = str_replace("{direccion}", $direccion, $sp);
      $sp = str_replace("{listadoIdEmpresas}", $listadoIdEmpresas, $sp);
      $sp = str_replace("{idUsuarioConectado}", $idUsuarioConectado, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * determina si un valor ya existe en base de datos para el usuario seleccionado
   * @param <type> $idUsuario
   * @param <type> $valor
   * @param <type> $campoARevisar
   * @return string
   * @author VSR, 01/01/2011
   */
  public static function verificarDuplicidad($idUsuario, $valor, $campoARevisar) {
    $estaDuplicado = "0";

    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_VerificarDuplicidad$campoARevisar({idUsuario}, '{valor}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{valor}", $valor, $sp);

      //ejecuta procedimiento
      $estaDuplicado = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $estaDuplicado = "0";
    }
    return $estaDuplicado;
  }

  /**
   * elimina un usuario
   * @param <type> $idUsuario
   * @return <type>
   * @author VSR, 01/01/2011
   */
  public static function eliminarDatos($idUsuario) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_EliminarDatos({idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR, Bd::ORIGEN_DATOS_DEFAULT ,"Status");
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina logicamente el registro
   * @param <type> $idUsuario
   * @param <type> $idUsuarioConectado
   * @return <type> 
   * @author VSR, 15/05/2012
   */
  public static function eliminacionLogica($idUsuario, $idUsuarioConectado) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_EliminacionLogica({idUsuario},{idUsuarioConectado});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{idUsuarioConectado}", $idUsuarioConectado, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * graba los datos del usuario que se registra
   * @param <type> $nombre
   * @param <type> $paterno
   * @param <type> $materno
   * @param <type> $username
   * @param <type> $password
   * @param <type> $email
   * @return string
   */
  public static function grabarDatosRegistrar($nombre, $paterno, $materno, $username, $password, $email) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_Usuario_GrabarDatosRegistrar('{nombre}', '{paterno}', '{materno}', '{username}', '{password}', '{email}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{paterno}", $paterno, $sp);
      $sp = str_replace("{materno}", $materno, $sp);
      $sp = str_replace("{username}", $username, $sp);
      $sp = str_replace("{password}", $password, $sp);
      $sp = str_replace("{email}", $email, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

//</editor-fold>
}

?>